/**
 * 用户相关表操作
 */
// 涉及的表名
const dbName = require("../config.js");
var dao = {};
var util = {};
// 初始化
dao.init = function(obj) {
	util = obj;
}
/**
 * 获取用户信息
 * 调用示例
 * let userInfo = await vk.daoCenter.userDao.findById(user_id);
 * @param {String} user_id 用户ID
 */
dao.findById = async (user_id) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.findById({
		dbName: dbName.user,
		id: user_id,
		fieldJson: { token: false, password: false },
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 根据whereJson获取单条记录
 * @param {Object} whereJson 条件
 * @param {Object} fieldJson 字段显示规则
 * 调用示例
let userInfo = await vk.daoCenter.userDao.findByWhereJson({

});
 */
dao.findByWhereJson = async (whereJson, fieldJson={ token: false, password: false }) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.findByWhereJson({
		dbName: dbName.user,
		whereJson,
		fieldJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 根据邀请码获取用户信息
 * let inviterUserInfo = await vk.daoCenter.userDao.findByInviteCode(invite_code);
 * @param {String} invite_code 邀请码
 */
dao.findByInviteCode = async (invite_code) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.findByWhereJson({
		dbName: dbName.user,
		whereJson: {
			my_invite_code: invite_code
		},
		fieldJson: { token: false, password: false }
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 增 - 添加一条记录
 * @param {Object} dataJson 添加的数据
 * 调用示例
await vk.daoCenter.userDao.add({

});
或
 * 调用示例
await vk.daoCenter.userDao.add({
	db: transaction,
	dataJson: {

	}
});
 */
dao.add = async (obj) => {
	let { vk, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	if (obj.db && obj.dataJson) {
		// 支持事务
		res = await vk.baseDao.add({
			...obj,
			cancelAddTime: true, // 因为user表使用了register_date作为创建时间
			dbName: dbName.user,
		});
	} else {
		// 不支持事务
		res = await vk.baseDao.add({
			dbName: dbName.user,
			cancelAddTime: true, // 因为user表使用了register_date作为创建时间
			dataJson: obj
		});
	}
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 增 - 添加多条记录
 * @param {Object} dataJson 添加的数据
 * 调用示例
await vk.daoCenter.userDao.adds(dataArr);
 */
dao.adds = async (dataArr) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.adds({
		dbName: dbName.user,
		cancelAddTime: true, // 因为user表使用了register_date作为创建时间
		dataJson: dataArr
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 删 - 删除多条记录
 * @param {Object} whereJson 条件
 * 调用示例
await vk.daoCenter.userDao.del({

});
 */
dao.del = async (whereJson) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.del({
		dbName: dbName.user,
		whereJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 删 - 据ID删除单条数据
 * @param {String} _id
 * 调用示例
await vk.daoCenter.userDao.deleteById(_id);
或
await vk.daoCenter.userDao.deleteById(_id, transaction);
 */
dao.deleteById = async (_id, db) => {
	let { vk, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.deleteById({
		db,
		dbName: dbName.user,
		id: _id
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 改
 * @param {Object} whereJson 条件
 * @param {Object} dataJson 修改的数据
 * 调用示例
await vk.daoCenter.userDao.update({
	whereJson:{

	},
	dataJson:{

	}
});
 */
dao.update = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.update({
		...obj,
		dbName: dbName.user
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 改
 * @param {Object} whereJson 条件
 * @param {Object} dataJson 修改的数据
 * 调用示例
await vk.daoCenter.userDao.updateById({
	id: uid,
	dataJson:{

	}
});
 */
dao.updateById = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.updateById({
		...obj,
		dbName: dbName.user
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 改 - 更新并返回更新后的数据（无论条件匹配到多少条记录，只会修改第一条记录，同时返回修改后的数据）
 * @param {Object} whereJson 条件
 * @param {Object} dataJson 修改的数据
 * 调用示例
await vk.daoCenter.userDao.updateAndReturn({
	whereJson:{

	},
	dataJson:{

	}
});
 */
dao.updateAndReturn = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.updateAndReturn({
		...obj,
		dbName: dbName.user
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 获取记录总条数
 * @param {Object} whereJson 条件
 * 调用示例
await vk.daoCenter.userDao.count(whereJson);
 */
dao.count = async (whereJson) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.count({
		dbName: dbName.user,
		whereJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 根据ID数组获取用户列表 最多支持500个
 * 调用示例
 * await vk.daoCenter.userDao.listByIds(userIdArr);
 * data 请求参数说明
 * @param {Array} userIdArr 用户ID数组
 */
dao.listByIds = async (userIdArr) => {
	let { vk, db, _ } = util;
	let res = {};
	let selectRes = await vk.baseDao.select({
		dbName: dbName.user,
		pageIndex: 1,
		pageSize: 500,
		fieldJson: { token: false, password: false },
		whereJson: {
			_id: _.in(userIdArr)
		},
	});
	res = selectRes.rows;
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 求和
 * @param {String} fieldName 需要求和的字段名
 * @param {Object} whereJson 筛选条件
 * 调用示例
let userSum = await vk.daoCenter.userDao.sum({
	fieldName: "",
	whereJson: {

	}
});
 */
dao.sum = async (obj) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.sum({
		...obj,
		dbName: dbName.user,
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 求最大值
 * @param {String} fieldName 需要求最大值的字段名
 * @param {Object} whereJson 筛选条件
 * 调用示例
let userMax = await vk.daoCenter.userDao.max({
	fieldName: "",
	whereJson: {

	}
});
 */
dao.max = async (obj) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.max({
		...obj,
		dbName: dbName.user,
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 求最小值
 * @param {String} fieldName 需要求最小值的字段名
 * @param {Object} whereJson 筛选条件
 * 调用示例
let userMin = await vk.daoCenter.userDao.min({
	fieldName: "",
	whereJson: {

	}
});
 */
dao.min = async (obj) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.min({
		...obj,
		dbName: dbName.user,
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 求最平均值
 * @param {String} fieldName 需要求最平均值的字段名
 * @param {Object} whereJson 筛选条件
 * 调用示例
let userAvg = await vk.daoCenter.userDao.avg({
	fieldName: "",
	whereJson: {

	}
});
 */
dao.avg = async (obj) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.avg({
		...obj,
		dbName: dbName.user,
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 获取数据列表
 * 调用示例
let userList = await vk.daoCenter.userDao.select({
	pageIndex:1,
	pageSize:20,
	getMain:false,
	whereJson:{

	},
	fieldJson:{},
	sortArr:[{ "name":"_id", "type":"desc" }],
});
 */
dao.select = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.select({
		...obj,
		dbName: dbName.user
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 获取数据列表
 * 调用示例
let userList = await vk.daoCenter.userDao.selects({
	pageIndex:1,
	pageSize:20,
	getMain:false,
	whereJson:{

	},
	fieldJson:{},
	sortArr:[{ "name":"_id", "type":"desc" }],
	// 副表列表
	foreignDB:[
		{
			dbName:"副表表名",
			localKey:"主表外键名",
			foreignKey:"副表外键名",
			as:"副表as字段",
			limit:1
		}
	]
});
 */
dao.selects = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.selects({
		...obj,
		dbName: dbName.user
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 获取数据列表
 * 调用示例
res = await vk.daoCenter.userDao.getTableData({ data });
 */
dao.getTableData = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.getTableData({
		...obj,
		dbName: dbName.user
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 获取用户信息（旧版）
 * _id
 * username
 * mobile
 * email
 * wx_openid.app-plus
 * wx_openid.mp-weixin
 * wx_unionid
 * ali_openid
 * my_invite_code
 * 调用示例
 await vk.daoCenter.userDao.findByUserInfo({
	mobile:mobile
 });
 * data 请求参数说明
 * @param {Object} userInfo 用户信息
 */
dao.findByUserInfo = async (userInfo) => {
	let { vk, db, _ } = util;
	let res;
	// 数据库操作开始-----------------------------------------------------------
	let whereJson = {};
	let list = [
		"_id",
		"username",
		"mobile",
		"email",
		"wx_openid.app-plus",
		"wx_openid.mp-weixin",
		"wx_unionid",
		"ali_openid",
		"my_invite_code"
	];
	let orArr = [];
	for (let i = 0; i < list.length; i++) {
		let keyName = list[i];
		let orObj = {};
		if (vk.pubfn.isNotNull(userInfo[keyName])) orObj[keyName] = userInfo[keyName];
		if (vk.pubfn.isNotNull(orObj)) {
			orArr.push(orObj);
		}
	}
	if (orArr.length > 0) {
		whereJson = _.or(orArr);
		res = await vk.baseDao.findByWhereJson({
			dbName: dbName.user,
			fieldJson: { token: false, password: false },
			whereJson: whereJson
		});
	}
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 根据手机号直接注册账号并登录
 * 若手机号已存在,则直接登录
 * @param {Object} data 参数
 * mobile          手机号  必填
 * password        初始密码
 * inviteCode      邀请人的邀请码
 * myInviteCode    设置当前注册用户自己的邀请码
 * needPermission  设置为true时会在checkToken时返回用户权限（permission），建议在管理控制台中使用
 * 调用示例
 await vk.daoCenter.userDao.registerUserByMobile({
	 mobile,
 });
 */
dao.registerUserByMobile = async (data) => {
	let { vk, db, _, uniID } = util;
	let res = {};
	let {
		mobile,
		password,
		inviteCode,
		myInviteCode,
		needPermission
	} = data;
	// 数据库操作开始-----------------------------------------------------------
	let code = vk.pubfn.random(6);
	// 设置验证码
	await uniID.setVerifyCode({
		mobile,
		code,
		expiresIn: 60,
		type: "login"
	});
	// 若手机号不存在，则注册并登录。存在，则直接登录。
	res = await uniID.loginBySms({
		mobile,
		code,
		password,
		inviteCode,
		myInviteCode,
		needPermission
	});
	if (res.uid && vk.pubfn.isNull(res.userInfo)) {
		res.userInfo = await vk.daoCenter.userDao.findById(res.uid);
	}
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 重置用户密码
 * data 请求参数说明
 * @param {String} uid 用户ID
 * @param {String} password 需要重置的密码
 * 调用示例
await vk.daoCenter.userDao.resetPwd({
	uid: uid,
	password: "123456"
});
 */
dao.resetPwd = async (data) => {
	let { vk, db, _, uniID } = util;
	let res = {};
	let {
		uid,
		password
	} = data;
	// 数据库操作开始-----------------------------------------------------------
	res = await uniID.resetPwd({ uid, password });
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 获取一个未被使用的6位数分享码
 * 调用示例
await vk.daoCenter.userDao.getValidInviteCode();
 */
dao.getValidInviteCode = async (data) => {
	let { vk, db, _ } = util;
	// 数据库操作开始-----------------------------------------------------------
	let inviteCode = await vk.pubfn.randomAsync(6, "23456789ABCDEFGHJKLMNPQRSTUVWXYZ", async (val)=>{
		let num = await vk.baseDao.count({
			dbName: dbName.user,
			whereJson:{
				my_invite_code: val
			}
		}, 10); // 最大重试10次
		return num === 0 ? true : false;
	});
	// 数据库操作结束-----------------------------------------------------------
	return inviteCode;
};

/**
 * 获取用户的默认收货地址（若无默认地址，则取is_default降序后的第一个地址）
 * 调用示例
let defaultAddress = await vk.daoCenter.userDao.getDefaultAddress(uid);
 */
dao.getDefaultAddress = async (uid) => {
	let { vk, db, _ } = util;
	let res = await vk.baseDao.select({
		dbName: dbName.address,
		getCount: false,
		getMain: true,
		getOne: true,
		pageIndex: 1,
		pageSize: 1,
		whereJson: {
			user_id: uid,
		},
		sortArr: [{ "name": "is_default", "type": "desc" }],
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 获取id获取收货地址
 * 调用示例
let addressInfo = await vk.daoCenter.userDao.getAddressById(address_id, uid);
 */
dao.getAddressById = async (address_id, uid) => {
	let { vk, db, _ } = util;
	let res = await vk.baseDao.findByWhereJson({
		dbName: dbName.address,
		whereJson: {
			_id: address_id,
			user_id: uid
		}
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 修改或设置推荐人
await vk.daoCenter.userDao.updateInviterUser({
	user_id, // 被分享人ID，与 userInfo 二选一
	inviter_id, // 分享人ID，与 inviterUserInfo 二选一
	userInfo, // 被分享人
	inviterUserInfo, // 分享人
	mode: 1,// 1:正常分享 2:系统分享人 3:无分享人
	clientInfo: this.getClientInfo(), // 日志需要
});
 */
dao.updateInviterUser = async (data) => {
	let { vk, db, _ } = util;
	let res = { code: 0, msg: '' };
	let {
		user_id, // 被分享人ID，与 userInfo 二选一
		inviter_id, // 分享人ID，与 inviterUserInfo 二选一
		userInfo, // 被分享人
		inviterUserInfo = {}, // 实际分享人
		originalShareUser, // 原始分享人
		mode = 1, // 1:正常分享 2:系统分享人 3:无分享人
		inviter_lock = 1, // 当mode=1时，是否要锁定该用户不可以被其他人的链接换绑
		clientInfo, // 客户端环境
	} = data;
	if (vk.pubfn.isNull(userInfo)) {
		if (vk.pubfn.isNull(user_id)) {
			return { code: -1, msg: '用户不能为空' };
		}
		userInfo = await vk.daoCenter.userDao.findById(user_id);
	}

	if (vk.pubfn.isNull(userInfo)) {
		return { code: -1, msg: '用户不能为空' };
	}
	if (typeof userInfo._id !== "string") {
		return { code: -1, msg: '用户id错误' };
	}
	let time = Date.now();
	let needUpdate = false; // 标记是否需要批量修改所有子用户的 inviter_uid 字段
	let set_inviter_uid;
	let dataJson = {};
	let inviterNickname = "";
	if (mode === 1) {
		/**
		 * 正常分享
		 * 上级必须存在
		 * 上级不能是自己
		 * 上级不能是自己的下级或下级的下级
		 */

		if (vk.pubfn.isNull(inviterUserInfo)) {
			if (vk.pubfn.isNull(inviter_id)) {
				return { code: -1, msg: '上级不能为空' };
			}
			inviterUserInfo = await vk.daoCenter.userDao.findById(inviter_id);
		}
		if (vk.pubfn.isNull(inviterUserInfo)) {
			return { code: -1, msg: '上级不能为空' };
		}
		if (inviterUserInfo._id === userInfo._id) {
			return { code: -1, msg: '上级不可以是自己' };
		}
		if (inviterUserInfo.inviter_uid && inviterUserInfo.inviter_uid.indexOf(userInfo._id) > -1) {
			return { code: -1, msg: '上级不可以是自己的下级' };
		}
		// 如果我的直属上级不是当前邀请人，则设置needUpdate=true
		if (!userInfo.inviter_uid || (userInfo.inviter_uid && userInfo.inviter_uid[0] !== inviterUserInfo._id)) {
			needUpdate = true;
		}
		// 拼接inviter_uid数组
		set_inviter_uid = inviterUserInfo.inviter_uid || [];
		set_inviter_uid.unshift(inviterUserInfo._id); // 将新的上级id添加到数组头部
		dataJson["inviter_uid"] = _.set(set_inviter_uid); // 设置全部上级
		dataJson["inviter_lock"] = inviter_lock; //设置 inviter_lock 为1后，该用户不会被其他人绑定
		// 当原始分享人和实际分享人不一致时，需要记录原始分享人信息
		if (originalShareUser && originalShareUser._id !== inviterUserInfo._id) {
			dataJson["fx.original_share_user"] = {
				_id: originalShareUser._id,
				nickname: originalShareUser.nickname,
				avatar: originalShareUser.avatar,
				invite_time: time
			};
		} else {
			dataJson["fx.original_share_user"] = _.remove();
		}
		inviterNickname = inviterUserInfo.nickname;
	} else if (mode === 2) {
		// 系统分享人
		set_inviter_uid = [];
		dataJson["inviter_lock"] = 1; //设置 inviter_lock 为1后，该用户不会被其他人绑定
		dataJson["inviter_uid"] = _.set(set_inviter_uid);
		dataJson["fx.original_share_user"] = _.remove();
		inviterNickname = "归属系统";
		needUpdate = true;
	} else if (mode === 3) {
		// 无分享人
		set_inviter_uid = [];
		dataJson["inviter_lock"] = 0; //设置 inviter_lock 为0后，该用户可以被其他人绑定
		dataJson["inviter_uid"] = _.remove();
		dataJson["fx.original_share_user"] = _.remove();
		inviterNickname = "无分享人";
		needUpdate = true;
	}
	// 更新受邀时间
	if (mode !== 1 || needUpdate) {
		dataJson["invite_time"] = time;
	}
	dataJson["fx.new_invite_time"] = time;
	res.num = await dao.updateById({
		id: userInfo._id,
		dataJson
	});
	if (res.num > 0 && needUpdate) {
		console.log("批量修改所有子用户的 inviter_uid 字段");
		// 删除数组指定条数的数据
		let delete_inviter_uid = userInfo.inviter_uid || [];
		if (delete_inviter_uid.length > 0) {
			res.num1 = await dao.update({
				whereJson: {
					inviter_uid: userInfo._id
				},
				dataJson: {
					inviter_uid: _.pull(_.in(delete_inviter_uid)),
				}
			});
			console.log("命令1：删除数组指定条数的数据", delete_inviter_uid, res.num1);
		}
		let add_inviter_uid = set_inviter_uid || [];
		if (add_inviter_uid.length > 0) {
			res.num2 = await dao.update({
				whereJson: {
					inviter_uid: userInfo._id
				},
				dataJson: {
					inviter_uid: _.push(add_inviter_uid),
				}
			});
			console.log("命令2：数组尾部添加指定条数的数据", add_inviter_uid, res.num2);
		}
		// A3修改前
		// A3: ["A2","A1"]
		// A4: ["A3","A2","A1"],
		// A5: ["A4","A3","A2","A1"],

		// A3分享人改B2
		// A3: ["B2","B1"],
		// A4: ["A3","B2","B1"],
		// A5: ["A4","A3","B2","B1"],

		// A3分享人改B1
		// A3: ["B1"],
		// A4: ["A3","B1"],
		// A5: ["A4","A3","B1"],

		// 添加分销邀请关系日志
		let content = `上级变更为【${inviterNickname}】`;
		if (originalShareUser && originalShareUser._id !== inviterUserInfo._id) {
			content = `通过点击【${originalShareUser.nickname}】的分享链接（非分销员），最终` + content;
		}
		await vk.daoCenter.fxLogDao.addInviterLog({
			user_id: userInfo._id,
			content,
			remark: ``,
			clientInfo
		});
	}

	res.msg = "绑定成功";
	return res;
};

/**
 * 获取可以解锁的奖励总和
 * 调用示例
let unlockRewardMoney = await vk.daoCenter.userDao.sumUnlockReward({
	user_id,
	time
});
 */
dao.sumUnlockReward = async (obj) => {
	let { vk, db, _ } = util;
	let {
		user_id = "___",
			time
	} = obj;
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.sum({
		dbName: dbName.rewardRec,
		fieldName: "value",
		whereJson: {
			user_id,
			is_freeze: true,
			unfreeze_time: _.lte(time)
		},
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 获取可以解锁的奖励总和
 * 调用示例
let unlockRewardCount = await vk.daoCenter.userDao.countUnlockReward({
	user_id,
	time
});
 */
dao.countUnlockReward = async (obj) => {
	let { vk, db, _ } = util;
	let {
		user_id = "___",
			time
	} = obj;
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.count({
		dbName: dbName.rewardRec,
		whereJson: {
			user_id,
			is_freeze: true,
			unfreeze_time: _.lte(time)
		},
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 解锁奖励
 * 调用示例
let updateNum = await vk.daoCenter.userDao.updateUnlockReward({
	user_id,
	time
});
 */
dao.updateUnlockReward = async (obj) => {
	let { vk, db, _ } = util;
	let {
		user_id = "___",
			time
	} = obj;
	// 数据库操作开始-----------------------------------------------------------
	res = await vk.baseDao.update({
		dbName: dbName.rewardRec,
		whereJson: {
			user_id,
			is_freeze: true,
			unfreeze_time: _.lte(time)
		},
		dataJson: {
			is_freeze: false,
			reality_unfreeze_time: time
		}
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 用户修改vip等级
 * 调用示例
await vk.daoCenter.userDao.updateVipLv({
	_id,
	//userInfo,
	lv: lv
});
 */
dao.updateVipLv = async (obj) => {
	let {
		_id,
		userInfo,
		lv,
	} = obj;
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	let currentUser;
	if (vk.pubfn.isNotNull(userInfo)) {
		currentUser = userInfo;
	} else if (vk.pubfn.isNotNull(_id)) {
		currentUser = await vk.daoCenter.userDao.findById(_id);
	} else {
		return 0;
	}
	if (currentUser.vip_lv === lv) {
		return 0;
	}
	let time = Date.now();
	let dataJson = {
		vip_lv: Number(lv),
		vip_lv_get_time: time, // 记录最新一次修改时间
	};
	if (lv == 0) {
		dataJson["vip_get_time"] = _.remove();
	} else if (currentUser.vip_lv == 0) {
		// 如果用户在升级前不是会员，则记录下成为会员的时间
		dataJson["vip_get_time"] = time;
	}
	res = await vk.baseDao.updateById({
		dbName: dbName.user,
		id: currentUser._id,
		dataJson
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 自动修改用户角色(如是否是区域代理)
 * 调用示例
await vk.daoCenter.userDao.checkUserFxRole(user_id);
 * data 请求参数说明
 * @params {String} jisu_user_token 用户token
 */
dao.checkUserFxRole = async (user_id, arr = ["region"]) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	if (arr.indexOf("region") > -1) {
		// 查询用户是否代理的区域
		let keyName = "region";
		let num = await vk.daoCenter.fxRegionalAgentDao.count({
			user_id
		});
		let dataJson = {};
		if (num) {
			dataJson["fx.role"] = _.addToSet(keyName);
		} else {
			dataJson["fx.role"] = _.pull(keyName);
		}
		await vk.daoCenter.userDao.updateById({
			id: user_id,
			dataJson
		});
	}
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 我的直推人数
 * 调用示例
let num1 = await vk.daoCenter.userDao.countShare1ByUserId({
	user_id: uid,
});
 */
dao.countShare1ByUserId = async (obj = {}) => {
	let { vk, db, _ } = util;
	// 数据库操作开始-----------------------------------------------------------
	let {
		user_id = "___"
	} = obj;
	res = await vk.daoCenter.userDao.count({
		["inviter_uid.0"]: user_id
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 查 - 我的团队人数
 * 调用示例
let num12 = await vk.daoCenter.userDao.countShare12ByUserId({
	user_id: uid,
});
 */
dao.countShare12ByUserId = async (obj = {}) => {
	let { vk, db, _ } = util;
	// 数据库操作开始-----------------------------------------------------------
	let {
		user_id = "___"
	} = obj;
	res = await vk.daoCenter.userDao.count(_.or([{
			["inviter_uid.0"]: user_id
		},
		{
			["inviter_uid.1"]: user_id
		}
	]));
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 用户修改分销等级
 * 调用示例
await vk.daoCenter.userDao.updateFxLv({
	_id,
	//userInfo,
	lv: lv
});
 */
dao.updateFxLv = async (obj) => {
	let {
		_id,
		userInfo,
		lv,
	} = obj;
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	let currentUser;
	if (vk.pubfn.isNotNull(userInfo)) {
		currentUser = userInfo;
	} else if (vk.pubfn.isNotNull(_id)) {
		currentUser = await vk.daoCenter.userDao.findById(_id);
	} else {
		return 0;
	}
	if (currentUser.fx.lv === lv) {
		return 0;
	}
	res = await vk.baseDao.updateById({
		dbName: dbName.user,
		id: currentUser._id,
		dataJson: {
			"fx.lv": lv
		}
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};

/**
 * 查 - 获取数据列表(只查询client端客户)
 * 调用示例
res = await vk.daoCenter.userDao.getTableDataForClient({ data });
 */
dao.getTableDataForClient = async (obj = {}) => {
	let { vk, db, _ } = util;
	let res = {};
	// 数据库操作开始-----------------------------------------------------------
	let appList = await vk.baseDao.select({
		dbName: dbName.appList,
		getCount: false,
		pageIndex: 1,
		pageSize: 500,
		getMain: true,
		whereJson: {
			type: "client"
		}
	});
	let appids = appList.map((item, index) => {
		return item.appid;
	});
	res = await vk.baseDao.getTableData({
		...obj,
		dbName: dbName.user,
		whereJson: {
			dcloud_appid: _.in([...appids, null]),
			...obj.whereJson
		},
	});
	// 数据库操作结束-----------------------------------------------------------
	return res;
};


/**
 * 查 - 判断用户是否已购买过指定的商品
 * 调用示例
let isBuyGoods = await vk.daoCenter.userDao.checkBuyGoods({
	user_id,
	goods_ids
});
 */
dao.checkBuyGoods = async (obj = {}) => {
	let { vk, db, _ } = util;
	let {
		user_id,
		goods_ids
	} = obj;
	let isBuyGoods = false;
	// 数据库操作开始-----------------------------------------------------------
	if (vk.pubfn.isNotNull(goods_ids)) {
		// 判断我是否买过指定的会员升级商品
		let count = await vk.daoCenter.orderDao.count({
			status: _.gt(0),// 订单必须已付款
			user_id: user_id,
			goods_sku_list:{
				goods_id: _.in(goods_ids)
			}
		});
		if (count > 0) {
			isBuyGoods = true; // 标记已购买过会员升级所需商品
		}
	}
	// 数据库操作结束-----------------------------------------------------------
	return isBuyGoods;
};

module.exports = dao;
